home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / distutils / cygwinccompiler.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-29  |  9.1 KB  |  278 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''distutils.cygwinccompiler
  5.  
  6. Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
  7. handles the Cygwin port of the GNU C compiler to Windows.  It also contains
  8. the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
  9. cygwin in no-cygwin mode).
  10. '''
  11. __revision__ = '$Id: cygwinccompiler.py 37828 2004-11-10 22:23:15Z loewis $'
  12. import os
  13. import sys
  14. import copy
  15. from distutils.ccompiler import gen_preprocess_options, gen_lib_options
  16. from distutils.unixccompiler import UnixCCompiler
  17. from distutils.file_util import write_file
  18. from distutils.errors import DistutilsExecError, CompileError, UnknownFileError
  19. from distutils import log
  20.  
  21. class CygwinCCompiler(UnixCCompiler):
  22.     compiler_type = 'cygwin'
  23.     obj_extension = '.o'
  24.     static_lib_extension = '.a'
  25.     shared_lib_extension = '.dll'
  26.     static_lib_format = 'lib%s%s'
  27.     shared_lib_format = '%s%s'
  28.     exe_extension = '.exe'
  29.     
  30.     def __init__(self, verbose = 0, dry_run = 0, force = 0):
  31.         UnixCCompiler.__init__(self, verbose, dry_run, force)
  32.         (status, details) = check_config_h()
  33.         self.debug_print("Python's GCC status: %s (details: %s)" % (status, details))
  34.         if status is not CONFIG_H_OK:
  35.             self.warn("Python's pyconfig.h doesn't seem to support your compiler. Reason: %s. Compiling may fail because of undefined preprocessor macros." % details)
  36.         
  37.         (self.gcc_version, self.ld_version, self.dllwrap_version) = get_versions()
  38.         self.debug_print(self.compiler_type + ': gcc %s, ld %s, dllwrap %s\n' % (self.gcc_version, self.ld_version, self.dllwrap_version))
  39.         if self.ld_version >= '2.10.90':
  40.             self.linker_dll = 'gcc'
  41.         else:
  42.             self.linker_dll = 'dllwrap'
  43.         if self.ld_version >= '2.13':
  44.             shared_option = '-shared'
  45.         else:
  46.             shared_option = '-mdll -static'
  47.         self.set_executables(compiler = 'gcc -mcygwin -O -Wall', compiler_so = 'gcc -mcygwin -mdll -O -Wall', compiler_cxx = 'g++ -mcygwin -O -Wall', linker_exe = 'gcc -mcygwin', linker_so = '%s -mcygwin %s' % (self.linker_dll, shared_option))
  48.         if self.gcc_version == '2.91.57':
  49.             self.dll_libraries = [
  50.                 'msvcrt']
  51.             self.warn('Consider upgrading to a newer version of gcc')
  52.         else:
  53.             self.dll_libraries = []
  54.             msc_pos = sys.version.find('MSC v.')
  55.             if msc_pos != -1:
  56.                 msc_ver = sys.version[msc_pos + 6:msc_pos + 10]
  57.                 if msc_ver == '1300':
  58.                     self.dll_libraries = [
  59.                         'msvcr70']
  60.                 elif msc_ver == '1310':
  61.                     self.dll_libraries = [
  62.                         'msvcr71']
  63.                 
  64.             
  65.  
  66.     
  67.     def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
  68.         if ext == '.rc' or ext == '.res':
  69.             
  70.             try:
  71.                 self.spawn([
  72.                     'windres',
  73.                     '-i',
  74.                     src,
  75.                     '-o',
  76.                     obj])
  77.             except DistutilsExecError:
  78.                 msg = None
  79.                 raise CompileError, msg
  80.             except:
  81.                 None<EXCEPTION MATCH>DistutilsExecError
  82.             
  83.  
  84.         None<EXCEPTION MATCH>DistutilsExecError
  85.         
  86.         try:
  87.             self.spawn(self.compiler_so + cc_args + [
  88.                 src,
  89.                 '-o',
  90.                 obj] + extra_postargs)
  91.         except DistutilsExecError:
  92.             msg = None
  93.             raise CompileError, msg
  94.  
  95.  
  96.     
  97.     def link(self, target_desc, objects, output_filename, output_dir = None, libraries = None, library_dirs = None, runtime_library_dirs = None, export_symbols = None, debug = 0, extra_preargs = None, extra_postargs = None, build_temp = None, target_lang = None):
  98.         if not extra_preargs:
  99.             pass
  100.         extra_preargs = copy.copy([])
  101.         if not libraries:
  102.             pass
  103.         libraries = copy.copy([])
  104.         if not objects:
  105.             pass
  106.         objects = copy.copy([])
  107.         libraries.extend(self.dll_libraries)
  108.         if export_symbols is not None:
  109.             if target_desc != self.EXECUTABLE or self.linker_dll == 'gcc':
  110.                 temp_dir = os.path.dirname(objects[0])
  111.                 (dll_name, dll_extension) = os.path.splitext(os.path.basename(output_filename))
  112.                 def_file = os.path.join(temp_dir, dll_name + '.def')
  113.                 lib_file = os.path.join(temp_dir, 'lib' + dll_name + '.a')
  114.                 contents = [
  115.                     'LIBRARY %s' % os.path.basename(output_filename),
  116.                     'EXPORTS']
  117.                 for sym in export_symbols:
  118.                     contents.append(sym)
  119.                 
  120.                 self.execute(write_file, (def_file, contents), 'writing %s' % def_file)
  121.                 if self.linker_dll == 'dllwrap':
  122.                     extra_preargs.extend([
  123.                         '--output-lib',
  124.                         lib_file])
  125.                     extra_preargs.extend([
  126.                         '--def',
  127.                         def_file])
  128.                 else:
  129.                     objects.append(def_file)
  130.             
  131.         if not debug:
  132.             extra_preargs.append('-s')
  133.         
  134.         UnixCCompiler.link(self, target_desc, objects, output_filename, output_dir, libraries, library_dirs, runtime_library_dirs, None, debug, extra_preargs, extra_postargs, build_temp, target_lang)
  135.  
  136.     
  137.     def object_filenames(self, source_filenames, strip_dir = 0, output_dir = ''):
  138.         if output_dir is None:
  139.             output_dir = ''
  140.         
  141.         obj_names = []
  142.         for src_name in source_filenames:
  143.             (base, ext) = os.path.splitext(os.path.normcase(src_name))
  144.             if ext not in self.src_extensions + [
  145.                 '.rc',
  146.                 '.res']:
  147.                 raise UnknownFileError, "unknown file type '%s' (from '%s')" % (ext, src_name)
  148.             
  149.             if strip_dir:
  150.                 base = os.path.basename(base)
  151.             
  152.             if ext == '.res' or ext == '.rc':
  153.                 obj_names.append(os.path.join(output_dir, base + ext + self.obj_extension))
  154.                 continue
  155.             obj_names.append(os.path.join(output_dir, base + self.obj_extension))
  156.         
  157.         return obj_names
  158.  
  159.  
  160.  
  161. class Mingw32CCompiler(CygwinCCompiler):
  162.     compiler_type = 'mingw32'
  163.     
  164.     def __init__(self, verbose = 0, dry_run = 0, force = 0):
  165.         CygwinCCompiler.__init__(self, verbose, dry_run, force)
  166.         if self.ld_version >= '2.13':
  167.             shared_option = '-shared'
  168.         else:
  169.             shared_option = '-mdll -static'
  170.         if self.gcc_version <= '2.91.57':
  171.             entry_point = '--entry _DllMain@12'
  172.         else:
  173.             entry_point = ''
  174.         self.set_executables(compiler = 'gcc -mno-cygwin -O -Wall', compiler_so = 'gcc -mno-cygwin -mdll -O -Wall', compiler_cxx = 'g++ -mno-cygwin -O -Wall', linker_exe = 'gcc -mno-cygwin', linker_so = '%s -mno-cygwin %s %s' % (self.linker_dll, shared_option, entry_point))
  175.         self.dll_libraries = []
  176.         msc_pos = sys.version.find('MSC v.')
  177.         if msc_pos != -1:
  178.             msc_ver = sys.version[msc_pos + 6:msc_pos + 10]
  179.             if msc_ver == '1300':
  180.                 self.dll_libraries = [
  181.                     'msvcr70']
  182.             elif msc_ver == '1310':
  183.                 self.dll_libraries = [
  184.                     'msvcr71']
  185.             
  186.         
  187.  
  188.  
  189. CONFIG_H_OK = 'ok'
  190. CONFIG_H_NOTOK = 'not ok'
  191. CONFIG_H_UNCERTAIN = 'uncertain'
  192.  
  193. def check_config_h():
  194.     '''Check if the current Python installation (specifically, pyconfig.h)
  195.     appears amenable to building extensions with GCC.  Returns a tuple
  196.     (status, details), where \'status\' is one of the following constants:
  197.       CONFIG_H_OK
  198.         all is well, go ahead and compile
  199.       CONFIG_H_NOTOK
  200.         doesn\'t look good
  201.       CONFIG_H_UNCERTAIN
  202.         not sure -- unable to read pyconfig.h
  203.     \'details\' is a human-readable string explaining the situation.
  204.  
  205.     Note there are two ways to conclude "OK": either \'sys.version\' contains
  206.     the string "GCC" (implying that this Python was built with GCC), or the
  207.     installed "pyconfig.h" contains the string "__GNUC__".
  208.     '''
  209.     sysconfig = sysconfig
  210.     import distutils
  211.     import string
  212.     if string.find(sys.version, 'GCC') >= 0:
  213.         return (CONFIG_H_OK, "sys.version mentions 'GCC'")
  214.     
  215.     fn = sysconfig.get_config_h_filename()
  216.     
  217.     try:
  218.         f = open(fn)
  219.         s = f.read()
  220.         f.close()
  221.     except IOError:
  222.         exc = None
  223.         return (CONFIG_H_UNCERTAIN, "couldn't read '%s': %s" % (fn, exc.strerror))
  224.  
  225.     if string.find(s, '__GNUC__') >= 0:
  226.         return (CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn)
  227.     else:
  228.         return (CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn)
  229.  
  230.  
  231. def get_versions():
  232.     ''' Try to find out the versions of gcc, ld and dllwrap.
  233.         If not possible it returns None for it.
  234.     '''
  235.     LooseVersion = LooseVersion
  236.     import distutils.version
  237.     find_executable = find_executable
  238.     import distutils.spawn
  239.     import re
  240.     gcc_exe = find_executable('gcc')
  241.     if gcc_exe:
  242.         out = os.popen(gcc_exe + ' -dumpversion', 'r')
  243.         out_string = out.read()
  244.         out.close()
  245.         result = re.search('(\\d+\\.\\d+(\\.\\d+)*)', out_string)
  246.         if result:
  247.             gcc_version = LooseVersion(result.group(1))
  248.         else:
  249.             gcc_version = None
  250.     else:
  251.         gcc_version = None
  252.     ld_exe = find_executable('ld')
  253.     if ld_exe:
  254.         out = os.popen(ld_exe + ' -v', 'r')
  255.         out_string = out.read()
  256.         out.close()
  257.         result = re.search('(\\d+\\.\\d+(\\.\\d+)*)', out_string)
  258.         if result:
  259.             ld_version = LooseVersion(result.group(1))
  260.         else:
  261.             ld_version = None
  262.     else:
  263.         ld_version = None
  264.     dllwrap_exe = find_executable('dllwrap')
  265.     if dllwrap_exe:
  266.         out = os.popen(dllwrap_exe + ' --version', 'r')
  267.         out_string = out.read()
  268.         out.close()
  269.         result = re.search(' (\\d+\\.\\d+(\\.\\d+)*)', out_string)
  270.         if result:
  271.             dllwrap_version = LooseVersion(result.group(1))
  272.         else:
  273.             dllwrap_version = None
  274.     else:
  275.         dllwrap_version = None
  276.     return (gcc_version, ld_version, dllwrap_version)
  277.  
  278.